home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / viewers / polyview / polyvw31.lha / Polyview3.1 / new / Xmx.c < prev    next >
C/C++ Source or Header  |  1993-07-12  |  35KB  |  1,288 lines
  1. /*****************************************************************************
  2.  * NCSA Xmx X/Motif Extension Library.                                       *
  3.  *                                                                           *
  4.  * Designed and Implemented by Marc Andreessen (marca@ncsa.uiuc.edu).        *
  5.  *                                                                           *
  6.  * Software Development Group                                                *
  7.  * National Center for Supercomputing Applications                           *
  8.  * University of Illinois at Urbana-Champaign.                               *
  9.  *                                                                           *
  10.  * This is BETA release software.  As such it may contain software bugs and  *
  11.  * exhibit inconsistencies.                                                  *
  12.  *                                                                           *
  13.  * Copyright (c) 1992 The Board of Trustees of the University of Illinois.   *
  14.  *                                                                           *
  15.  * Permission to use, copy, and modify this software and its                 *
  16.  * documentation for educational, research, and non-profit purposes is       *
  17.  * hereby granted, provided that the above copyright notice, the original    *
  18.  * authors names, and this permission notice appear in all such copies.      *
  19.  * Any distribution of this software requires the explicit and written       *
  20.  * authorization of the authors.                                             *
  21.  *                                                                           *
  22.  * The University of Illinois makes no representations about the             *
  23.  * suitability of this software for any purpose.  It is provided "as is"     *
  24.  * without warranty of any kind.                                             *
  25.  *****************************************************************************/
  26.  
  27. /* $Header: /usr3/people/gbourhis/pv3/new/RCS/Xmx.c,v 1.2 93/07/12 09:32:05 gbourhis Exp $ */
  28.  
  29. #ifdef RCSLOG
  30. $Log:    Xmx.c,v $
  31.  * Revision 1.2  93/07/12  09:32:05  gbourhis
  32.  * Convert XmxSetArg() function to a cpp macro.
  33.  * 
  34.  * Revision 1.1  92/09/18  10:55:26  marca
  35.  * Initial revision
  36.  * 
  37. #endif
  38.  
  39. #include "XmxP.h"
  40.  
  41. /* ---------------------------- FILE VARIABLES ---------------------------- */
  42.  
  43. /* Variables accessed through Xmx.h as extern. */
  44. int    Xmx_n = 0;
  45. Arg    Xmx_wargs[XmxMaxNumArgs];
  46. Widget Xmx_w;
  47. int    Xmx_uniqid = 0;
  48.  
  49. /* Counter for values returned from XmxMakeNewUniqid. */
  50. static int Xmx_uniqid_counter = 0;
  51.  
  52. /* Flag for whether or not XmxSetUniqid has ever been called. */
  53. static int Xmx_uniqid_has_been_set = 0;
  54.  
  55. /* --------------------------- UNIQID FUNCTIONS --------------------------- */
  56.  
  57. int
  58. XmxMakeNewUniqid (void)
  59. {
  60.   Xmx_uniqid_counter++;
  61.  
  62.   return Xmx_uniqid_counter;;
  63. }
  64.  
  65. void
  66. XmxSetUniqid (int uniqid)
  67. {
  68.   Xmx_uniqid = uniqid;
  69.   Xmx_uniqid_has_been_set = 1;
  70.  
  71.   return;
  72. }
  73.  
  74. void
  75. XmxZeroUniqid (void)
  76. {
  77.   Xmx_uniqid = 0;
  78.   /* Do NOT reset Xmx_uniqid_has_been_set. */
  79.  
  80.   return;
  81. }
  82.  
  83. int
  84. XmxExtractUniqid (int cd)
  85. {
  86.   /* Pull the high 16 bits, if uniqid has been set. */
  87.   if (Xmx_uniqid_has_been_set)
  88.     return (cd >> 16);
  89.   else
  90.     return 0;
  91. }
  92.  
  93. int
  94. XmxExtractToken (int cd)
  95. {
  96.   /* Pull the low 16 bits, if uniqid has been set. */
  97.   if (Xmx_uniqid_has_been_set)
  98.     return ((cd << 16) >> 16);
  99.   else
  100.     return cd;
  101. }
  102.  
  103. /* This function should be called by every Xmx routine
  104.    when registering a callback or event handler. */
  105. /* This is PRIVATE but accessible to Xmx2.c also. */
  106. int
  107. _XmxMakeClientData (int token)
  108. {
  109.   if (Xmx_uniqid_has_been_set)
  110.     return ((Xmx_uniqid << 16) | token);
  111.   else
  112.     return token;
  113. }
  114.  
  115. /* -------------------------- INTERNAL CALLBACKS -------------------------- */
  116.  
  117. /* Internal routine to unmanage file selection box on Cancel. */
  118. static
  119. XmxCallback(_XmxCancelCallback)
  120. {
  121.   XtUnmanageChild (w);
  122.  
  123.   return;
  124. }
  125.  
  126.  
  127. /* --------------------------- CALLBACK SUPPORT --------------------------- */
  128.  
  129. /* args do nothing */
  130. void XmxAddCallback (Widget w, String name, XtCallbackProc cb, int cb_data)
  131. {
  132.   XtAddCallback (w, name, cb, _XmxMakeClientData (cb_data));
  133.   return;
  134. }
  135.  
  136.  
  137. /* ------------------------ EVENT HANDLER SUPPORT ------------------------- */
  138.  
  139. void
  140. XmxAddEventHandler (Widget w, EventMask event_mask, XtEventHandler proc,
  141.                     int client_data)
  142. {
  143.   XtAddEventHandler 
  144.     (w, event_mask, False, proc, _XmxMakeClientData (client_data));
  145.  
  146.   return;
  147. }
  148.  
  149. void
  150. XmxRemoveEventHandler (Widget w, EventMask event_mask, XtEventHandler proc,
  151.                        int client_data)
  152. {
  153.   XtRemoveEventHandler
  154.     (w, event_mask, False, proc, _XmxMakeClientData (client_data));
  155.  
  156.   return;
  157. }
  158.  
  159.  
  160. /* ------------------- (nonworking) CENTERING ROUTINES -------------------- */
  161.  
  162. #ifdef NONWORKING_CENTERING
  163.  
  164. /* Adapted from Dan Heller's post in comp.windows.x.motif;
  165.    assumes BulletinBoard with one (centered) child. */
  166. static void
  167. XmxCenteringResize 
  168.   (CompositeWidget w, XConfigureEvent *event, String args[], int *num_args)
  169. {
  170.   WidgetList children;
  171.   int width = event->width;
  172.   int height = event->height;
  173.   Dimension w_width, w_height; 
  174.   
  175.   /* get handle to BulletinBoard's children and marginal spacing */
  176.   XtVaGetValues (w,
  177.                  XmNchildren, &children,
  178.                  NULL);
  179.   
  180.   XtVaGetValues (children[0],
  181.                  XmNheight, &w_height,
  182.                  XmNwidth, &w_width,
  183.                  NULL);
  184.   XtVaSetValues (children[0],
  185.                  XmNx, width/2 - w_width/2,
  186.                  XmNy, height/2 - w_height/2,
  187.                  NULL);
  188.                  
  189.   return;
  190. }
  191.  
  192. #endif /* NONWORKING_CENTERING */
  193.  
  194. /* -------------------------- UTILITY FUNCTIONS --------------------------- */
  195.  
  196. /* resets args */
  197. void XmxStartup (void)
  198. {
  199.   Xmx_n = 0;
  200.   return;
  201. }
  202.  
  203. /* sets an arg */
  204. #if 0
  205. void XmxSetArg (String arg, XtArgVal val)
  206. {
  207.   XtSetArg (Xmx_wargs[Xmx_n], arg, val);
  208.   Xmx_n++;
  209.   return;
  210. }
  211. #endif
  212.  
  213. void XmxSetValues (Widget w)
  214. {
  215.   XtSetValues (w, Xmx_wargs, Xmx_n);
  216.   Xmx_n = 0;
  217.   return;
  218. }
  219.  
  220. /* args do nothing */
  221. void XmxManageRemanage (Widget w)
  222. {
  223. #if 0
  224.   if (XtIsManaged (w))
  225.     XtUnmanageChild (w);
  226.   XtManageChild (w);
  227. #endif
  228.  
  229.   if (XtIsManaged (w))
  230.     XRaiseWindow (XtDisplay (w), XtWindow (w));
  231.   else
  232.     XtManageChild (w);
  233.  
  234.   return;
  235. }
  236.  
  237. /* args do nothing */
  238. void XmxSetSensitive (Widget w, int state)
  239. {
  240.   assert (state == XmxSensitive || state == XmxUnsensitive);
  241.   XtSetSensitive (w, (state == XmxSensitive) ? True : False);
  242.  
  243.   return;
  244. }
  245.  
  246. /* ------------------------------------------------------------------------ */
  247. /* ---------------- WIDGET CREATION AND HANDLING ROUTINES ----------------- */
  248. /* ------------------------------------------------------------------------ */
  249.  
  250. /* ----------------------------- PUSHBUTTONS ------------------------------ */
  251.  
  252. /* args work */
  253. Widget XmxMakePushButton (Widget parent, String name, XtCallbackProc cb,
  254.                           int cb_data)
  255. {
  256.   if (name)
  257.     XmxSetArg (XmNlabelString,
  258.            XmStringCreateLtoR (name, XmSTRING_DEFAULT_CHARSET));
  259.   Xmx_w = XtCreateManagedWidget ("pushbutton", xmPushButtonGadgetClass,
  260.                                  parent, Xmx_wargs, Xmx_n);
  261.   XtAddCallback (Xmx_w, XmNactivateCallback, cb, _XmxMakeClientData (cb_data));
  262.  
  263.   Xmx_n = 0;
  264.   return Xmx_w;
  265. }
  266.  
  267. /* args work */
  268. Widget XmxMakeBlankButton (Widget parent, XtCallbackProc cb,
  269.                int cb_data)
  270. {
  271.   Xmx_w = XtCreateManagedWidget ("blankbutton", xmPushButtonWidgetClass,
  272.                                  parent, Xmx_wargs, Xmx_n);
  273.   XtAddCallback (Xmx_w, XmNactivateCallback, cb, _XmxMakeClientData (cb_data));
  274.   
  275.   Xmx_n = 0;
  276.   return Xmx_w;
  277. }
  278.  
  279. /* ------------------------------- COMMAND -------------------------------- */
  280.  
  281. /* args work */
  282. Widget XmxMakeCommand 
  283.   (Widget parent, String prompt, XtCallbackProc cb, int cb_data)
  284. {
  285.   /* Probably not necessary. */
  286.   /* XmxSetArg (XmNresizePolicy, XmRESIZE_ANY); */
  287.   XmxSetArg (XmNpromptString, XmxMakeXmstrFromString (prompt));
  288.   Xmx_w = XtCreateManagedWidget ("command", xmCommandWidgetClass, parent,
  289.                  Xmx_wargs, Xmx_n);
  290.   XtAddCallback 
  291.     (Xmx_w, XmNcommandEnteredCallback, cb, _XmxMakeClientData (cb_data));
  292.  
  293.   Xmx_n = 0;
  294.   return Xmx_w;
  295. }
  296.  
  297. /* ----------------------------- DRAWING AREA ----------------------------- */
  298.  
  299. /* args work */
  300. Widget XmxMakeDrawingArea (Widget parent, int width, int height)
  301. {
  302.   XmxSetArg (XmNwidth, width);
  303.   XmxSetArg (XmNheight, height);
  304.   Xmx_w = XtCreateManagedWidget ("drawingarea", xmDrawingAreaWidgetClass,
  305.                  parent, Xmx_wargs, Xmx_n);
  306.  
  307.   Xmx_n = 0;
  308.   return Xmx_w;
  309. }
  310.  
  311. /* ------------------------ TOGGLE BUTTONS & BOXES ------------------------ */
  312.  
  313. /* args work */
  314. Widget XmxMakeRadioBox (Widget parent)
  315. {
  316.   /* Could set XmxNspacing here to avoid having to play with
  317.      margins for each togglebutton. */
  318.   XmxSetArg (XmNspacing, 0);
  319.   XmxSetArg (XmNentryClass, xmToggleButtonGadgetClass);
  320.   Xmx_w = XmCreateRadioBox (parent, "radiobox", Xmx_wargs, Xmx_n);
  321.   XtManageChild (Xmx_w);
  322.  
  323.   Xmx_n = 0;
  324.   return Xmx_w;
  325. }
  326.  
  327. /* args work */
  328. Widget XmxMakeOptionBox (Widget parent)
  329. {
  330.   XmxSetArg (XmNentryClass, xmToggleButtonGadgetClass);
  331.   XmxSetArg (XmNisHomogeneous, True);
  332.   Xmx_w = XtCreateManagedWidget ("optionbox", xmRowColumnWidgetClass,
  333.                                  parent, Xmx_wargs, Xmx_n);
  334.   Xmx_n = 0;
  335.   return Xmx_w;
  336. }
  337.  
  338. /* args work */
  339. Widget XmxMakeToggleButton (Widget parent, String name, XtCallbackProc cb,
  340.                             int cb_data)
  341. {
  342.   XmxSetArg (XmNlabelString,
  343.              XmStringCreateLtoR (name, XmSTRING_DEFAULT_CHARSET));
  344.   XmxSetArg (XmNmarginHeight, 0);
  345.   Xmx_w = XtCreateManagedWidget
  346.     ("togglebutton", xmToggleButtonGadgetClass, parent, Xmx_wargs, Xmx_n);
  347.   /* Used to be XmNarmCallback --- probably not right. */
  348.   XtAddCallback (Xmx_w, XmNvalueChangedCallback, cb, 
  349.                  _XmxMakeClientData (cb_data));
  350.  
  351.   Xmx_n = 0;
  352.   return Xmx_w;
  353. }
  354.  
  355. /* args work */
  356. void XmxSetToggleButton (Widget button, int set_state)
  357. {
  358.   assert (set_state == XmxSet || set_state == XmxUnset);
  359.   XmToggleButtonGadgetSetState 
  360.     (button, (set_state == XmxSet) ? True : False, False);
  361.  
  362.   Xmx_n = 0;
  363.   return;
  364. }
  365.  
  366. /* -------------------------------- SCALES -------------------------------- */
  367.  
  368. /* args ignored if label is non-NULL, otherwise args work */
  369. Widget XmxMakeScale (Widget parent, XtCallbackProc cb, int cb_data,
  370.                      String label, int min, int max, int start, int dec_adj)
  371. {
  372.   if (label)
  373.     {
  374.       Xmx_n = 0;
  375.       XmxMakeLabel (parent, label);
  376.     }
  377.  
  378.   XmxSetArg (XmNminimum, min);
  379.   XmxSetArg (XmNmaximum, max);
  380.   XmxSetArg (XmNvalue, start);
  381.   XmxSetArg (XmNorientation, XmHORIZONTAL);
  382.   XmxSetArg (XmNprocessingDirection, XmMAX_ON_RIGHT);
  383.   if (dec_adj != XmxNotDisplayed)
  384.     {
  385.       XmxSetArg (XmNshowValue, True);
  386.       XmxSetArg (XmNdecimalPoints, dec_adj);
  387.     }
  388.   Xmx_w = XtCreateManagedWidget ("scale", xmScaleWidgetClass, parent,
  389.                                  Xmx_wargs, Xmx_n);
  390.  
  391.   XtAddCallback 
  392.     (Xmx_w, XmNvalueChangedCallback, cb, _XmxMakeClientData (cb_data));
  393.   XtAddCallback (Xmx_w, XmNdragCallback, cb, _XmxMakeClientData (cb_data));
  394.  
  395.   Xmx_n = 0;
  396.   return Xmx_w;
  397. }
  398.  
  399. /* args work */
  400. void XmxAdjustScale (Widget scale, int val)
  401. {
  402.   XmxSetArg (XmNvalue, val);
  403.   XtSetValues (scale, Xmx_wargs, Xmx_n);
  404.  
  405.   Xmx_n = 0;
  406.   return;
  407. }
  408.  
  409.  
  410. /* args work */
  411. Widget XmxMakeFrame (Widget parent, int shadow)
  412. {
  413.   assert (shadow == XmxShadowIn || shadow == XmxShadowOut || shadow == XmxShadowEtchedIn || shadow == XmxShadowEtchedOut);
  414.   switch (shadow)
  415.     {
  416.     case XmxShadowIn:
  417.       XmxSetArg (XmNshadowType, XmSHADOW_IN);  break;
  418.     case XmxShadowOut:
  419.       XmxSetArg (XmNshadowType, XmSHADOW_OUT);  break;
  420.     case XmxShadowEtchedIn:
  421.       XmxSetArg (XmNshadowType, XmSHADOW_ETCHED_IN);  break;
  422.     case XmxShadowEtchedOut:
  423.       XmxSetArg (XmNshadowType, XmSHADOW_ETCHED_OUT);  break;
  424.     }
  425.   Xmx_w = XtCreateManagedWidget ("frame", xmFrameWidgetClass,
  426.                                  parent, Xmx_wargs, Xmx_n);
  427.  
  428.   Xmx_n = 0;
  429.   return Xmx_w;
  430. }
  431.  
  432. /* -------------------------------- FORMS --------------------------------- */
  433.  
  434. /* args work */
  435. Widget XmxMakeForm (Widget parent)
  436. {
  437.   Xmx_w = XtCreateManagedWidget ("form", xmFormWidgetClass, parent,
  438.                  Xmx_wargs, Xmx_n);
  439.   Xmx_n = 0;
  440.   return Xmx_w;
  441. }
  442.  
  443. /* args sent to w */
  444. void XmxSetPositions (Widget w, int top, int bottom, int left, int right)
  445. {
  446.   if (top != XmxNoPosition)
  447.     {
  448.       XmxSetArg (XmNtopAttachment, XmATTACH_POSITION);
  449.       XmxSetArg (XmNtopPosition, top);
  450.     }
  451.   if (bottom != XmxNoPosition)
  452.     {
  453.       XmxSetArg (XmNbottomAttachment, XmATTACH_POSITION);
  454.       XmxSetArg (XmNbottomPosition, bottom);
  455.     }
  456.   if (left != XmxNoPosition)
  457.     {
  458.       XmxSetArg (XmNleftAttachment, XmATTACH_POSITION);
  459.       XmxSetArg (XmNleftPosition, left);
  460.     }
  461.   if (right != XmxNoPosition)
  462.     {
  463.       XmxSetArg (XmNrightAttachment, XmATTACH_POSITION);
  464.       XmxSetArg (XmNrightPosition, right);
  465.     }
  466.  
  467.   XmxSetValues (w);
  468.  
  469.   Xmx_n = 0;
  470.   return;
  471. }
  472.  
  473. /* args sent to w */
  474. void XmxSetOffsets (Widget w, int top, int bottom, int left, int right)
  475. {
  476.   if (top != XmxNoOffset)
  477.     XmxSetArg (XmNtopOffset, top);
  478.   if (bottom != XmxNoOffset)
  479.     XmxSetArg (XmNbottomOffset, bottom);
  480.   if (left != XmxNoOffset)
  481.     XmxSetArg (XmNleftOffset, left);
  482.   if (right != XmxNoOffset)
  483.     XmxSetArg (XmNrightOffset, right);
  484.   
  485.   XmxSetValues (w);
  486.  
  487.   Xmx_n = 0;
  488.   return;
  489. }
  490.  
  491. /* args sent to w */
  492. void XmxSetConstraints (Widget w, 
  493.             int top, int bottom, int left, int right,
  494.             Widget topw, Widget botw, Widget lefw, Widget rigw)
  495. {
  496.   if (top != XmATTACH_NONE)
  497.     {
  498.       XmxSetArg (XmNtopAttachment, top);
  499.       if (topw)
  500.         XmxSetArg (XmNtopWidget, topw);
  501.     }
  502.   
  503.   if (bottom != XmATTACH_NONE)
  504.     {
  505.       XmxSetArg (XmNbottomAttachment, bottom);
  506.       if (botw)
  507.         XmxSetArg (XmNbottomWidget, botw);
  508.     }
  509.  
  510.   if (left != XmATTACH_NONE)
  511.     {
  512.       XmxSetArg (XmNleftAttachment, left);
  513.       if (lefw)
  514.         XmxSetArg (XmNleftWidget, lefw);
  515.     }
  516.  
  517.   if (right != XmATTACH_NONE)
  518.     {
  519.       XmxSetArg (XmNrightAttachment, right);
  520.       if (rigw)
  521.         XmxSetArg (XmNrightWidget, rigw);
  522.     }
  523.   
  524.   XmxSetValues (w);
  525.  
  526.   Xmx_n = 0;
  527.   return;
  528. }
  529.  
  530. /* ------------------------------ ROWCOLUMNS ------------------------------ */
  531.  
  532. /* args work */
  533. Widget XmxMakeVerticalRowColumn (Widget parent)
  534. {
  535.   Xmx_w = XtCreateManagedWidget ("rowcolumn", xmRowColumnWidgetClass,
  536.                                  parent, Xmx_wargs, Xmx_n);
  537.   Xmx_n = 0;
  538.   return Xmx_w;
  539. }
  540.  
  541. /* args work */
  542. Widget XmxMakeHorizontalRowColumn (Widget parent)
  543. {
  544.   XmxSetArg (XmNorientation, XmHORIZONTAL);
  545.   /* XmxSetArg (XmNmarginHeight, 0);
  546.   XmxSetArg (XmNmarginWidth, 0); */
  547.   Xmx_w = XtCreateManagedWidget ("rowcolumn", xmRowColumnWidgetClass,
  548.                                  parent, Xmx_wargs, Xmx_n);
  549.   Xmx_n = 0;
  550.   return Xmx_w;
  551. }
  552.  
  553. /* args work */
  554. Widget XmxMakeNColumnRowColumn (Widget parent, int ncolumns)
  555. {
  556.   XmxSetArg (XmNorientation, XmVERTICAL);
  557.   XmxSetArg (XmNpacking, XmPACK_COLUMN);
  558.   XmxSetArg (XmNnumColumns, ncolumns);
  559.   Xmx_w = XtCreateManagedWidget ("rowcolumn", xmRowColumnWidgetClass,
  560.                                  parent, Xmx_wargs, Xmx_n);
  561.   Xmx_n = 0;
  562.   return Xmx_w;
  563. }
  564.  
  565. /* --------------------------- BULLETIN BOARDS ---------------------------- */
  566.  
  567. /* args work */
  568. Widget XmxMakeVerticalBboard (Widget parent)
  569. {
  570.   Xmx_w = XtCreateManagedWidget ("bboard", xmBulletinBoardWidgetClass,
  571.                                  parent, Xmx_wargs, Xmx_n);
  572.   Xmx_n = 0;
  573.   return Xmx_w;
  574. }
  575.  
  576. /* args work */
  577. Widget XmxMakeVerticalBboardWithFont (Widget parent, String fontname)
  578. {
  579.   XFontStruct *_font;
  580.   XmFontList _fontlist;
  581.  
  582.   _font = XLoadQueryFont (XtDisplay (parent), fontname);
  583.   if (_font != (XFontStruct *)NULL)
  584.     {
  585.       _fontlist = XmFontListCreate (_font, XmSTRING_DEFAULT_CHARSET);
  586.       XmxSetArg (XmNbuttonFontList, _fontlist);
  587.       XmxSetArg (XmNlabelFontList, _fontlist);
  588.       XmxSetArg (XmNtextFontList, _fontlist);
  589.     }
  590.   XmxSetArg (XmNmarginWidth, 0);
  591.   XmxSetArg (XmNmarginHeight, 0);
  592.   Xmx_w = XtCreateManagedWidget ("bboard", xmBulletinBoardWidgetClass,
  593.                                  parent, Xmx_wargs, Xmx_n);
  594.  
  595.   Xmx_n = 0;
  596.   return Xmx_w;
  597. }
  598.  
  599. /* args work */
  600. Widget XmxMakeHorizontalBboard (Widget parent)
  601. {
  602.   XmxSetArg (XmNorientation, XmHORIZONTAL);
  603.   Xmx_w = XtCreateManagedWidget ("bboard", xmBulletinBoardWidgetClass,
  604.                               parent, Xmx_wargs, Xmx_n);
  605.   Xmx_n = 0;
  606.   return Xmx_w;
  607. }
  608.  
  609. /* -------------------- (nonworking) CENTERING BBOARD --------------------- */
  610.  
  611. #ifdef NONWORKING_CENTERING
  612.  
  613. /* args work */
  614. Widget XmxMakeCenteringBboard (Widget parent, XtAppContext app)
  615. {
  616.   XtActionsRec rec;
  617.  
  618.   Xmx_w = XtCreateManagedWidget 
  619.     ("bboard", xmBulletinBoardWidgetClass, parent, Xmx_wargs, Xmx_n);
  620.  
  621.   /* Does this have to happen more than once? */
  622.   rec.string = "resize";
  623.   rec.proc = XmxCenteringResize;
  624.   XtAppAddActions (app, &rec, 1);
  625.  
  626.   /* This does, for sure... */
  627.   XtOverrideTranslations 
  628.     (Xmx_w, XtParseTranslationTable ("<Configure>: resize()"));
  629.   
  630.   Xmx_n = 0;
  631.   return Xmx_w;
  632. }
  633.  
  634. #endif /* NONWORKING_CENTERING */
  635.  
  636. /* -------------------------------- LABELS -------------------------------- */
  637.  
  638. /* args work */
  639. void XmxAdjustLabelText (Widget label, String text)
  640. {
  641.   XmxSetArg (XmNlabelString,
  642.          XmStringCreateLtoR (text, XmSTRING_DEFAULT_CHARSET));
  643.   XtSetValues (label, Xmx_wargs, Xmx_n);
  644.  
  645.   Xmx_n = 0;
  646.   return;
  647. }
  648.  
  649. /* args work */
  650. Widget XmxMakeLabel (Widget parent, String name)
  651. {
  652.   XmxSetArg (XmNlabelString,
  653.              XmStringCreateLtoR (name, XmSTRING_DEFAULT_CHARSET));
  654.   Xmx_w = XtCreateManagedWidget ("label", xmLabelGadgetClass,
  655.                                  parent, Xmx_wargs, Xmx_n);
  656.   Xmx_n = 0;
  657.   return Xmx_w;
  658. }
  659.  
  660. /* args work */
  661. Widget XmxMakeBlankLabel (Widget parent)
  662. {
  663.   Xmx_w = XtCreateManagedWidget ("label", xmLabelWidgetClass,
  664.                                  parent, Xmx_wargs, Xmx_n);
  665.   Xmx_n = 0;
  666.   return Xmx_w;
  667. }
  668.  
  669. /* ------------------------------- DIALOGS -------------------------------- */
  670.  
  671. /* args work */
  672. Widget XmxMakeErrorDialog (Widget parent, String name, String title)
  673. {
  674.   XmxSetArg (XmNmessageString,
  675.              XmStringCreateLtoR (name, XmSTRING_DEFAULT_CHARSET));
  676.   XmxSetArg (XmNdialogTitle,
  677.              XmStringCreateLtoR (title, XmSTRING_DEFAULT_CHARSET));
  678.  
  679.   Xmx_w = XmCreateErrorDialog (parent, "error", Xmx_wargs, Xmx_n);
  680.   XtUnmanageChild (XmMessageBoxGetChild (Xmx_w, XmDIALOG_CANCEL_BUTTON));
  681.   XtUnmanageChild (XmMessageBoxGetChild (Xmx_w, XmDIALOG_HELP_BUTTON));
  682.  
  683.   Xmx_n = 0;
  684.   return Xmx_w;
  685. }
  686.  
  687. /* args work */
  688. Widget XmxMakeInfoDialog (Widget parent, String name, String title)
  689. {
  690.   XmxSetArg (XmNmessageString,
  691.              XmStringCreateLtoR (name, XmSTRING_DEFAULT_CHARSET));
  692.   XmxSetArg (XmNdialogTitle,
  693.              XmStringCreateLtoR (title, XmSTRING_DEFAULT_CHARSET));
  694.  
  695.   Xmx_w = XmCreateInformationDialog (parent, "infozoid", Xmx_wargs, Xmx_n);
  696.   XtUnmanageChild (XmMessageBoxGetChild (Xmx_w, XmDIALOG_CANCEL_BUTTON));
  697.   XtUnmanageChild (XmMessageBoxGetChild (Xmx_w, XmDIALOG_HELP_BUTTON));
  698.  
  699.   Xmx_n = 0;
  700.   return Xmx_w;
  701. }
  702.  
  703. /* args work */
  704. Widget XmxMakeQuestionDialog (Widget parent, String question, String title,
  705.                   XtCallbackProc cb, int yes_token, int no_token)
  706. {
  707.   XmxSetArg (XmNmessageString,
  708.              XmStringCreateLtoR (question, XmSTRING_DEFAULT_CHARSET));
  709.   XmxSetArg (XmNdialogTitle,
  710.              XmStringCreateLtoR (title, XmSTRING_DEFAULT_CHARSET));
  711.   XmxSetArg (XmNokLabelString,
  712.          XmStringCreateLtoR ("Yes", XmSTRING_DEFAULT_CHARSET));
  713.   XmxSetArg (XmNcancelLabelString,
  714.          XmStringCreateLtoR ("No", XmSTRING_DEFAULT_CHARSET));
  715.   
  716.   Xmx_w = XmCreateQuestionDialog (parent, "question", Xmx_wargs, Xmx_n);
  717.   XtUnmanageChild (XmMessageBoxGetChild (Xmx_w, XmDIALOG_HELP_BUTTON));
  718.  
  719.   XtAddCallback (Xmx_w, XmNcancelCallback, cb, _XmxMakeClientData (no_token));
  720.   XtAddCallback (Xmx_w, XmNokCallback, cb, _XmxMakeClientData (yes_token));
  721.  
  722.   Xmx_n = 0;
  723.   return Xmx_w;
  724. }
  725.  
  726. /* ----------------------------- STRING UTILS ----------------------------- */
  727.  
  728. /* args do nothing */
  729. XmString XmxMakeXmstrFromFile (String filename)
  730. {
  731.   FILE *_f;
  732.   char _mstr[81];
  733.   XmString _xmstr;
  734.  
  735.   _f = fopen (filename, "r");
  736.   assert (_f != (FILE *)NULL);
  737.  
  738.   _xmstr = (XmString)NULL;
  739.   while (!feof (_f))
  740.     {
  741.       if (fgets (_mstr, 80, _f) == (char *)NULL)
  742.         break;
  743.       _mstr[strlen (_mstr)-1] = '\0';
  744.       if (_xmstr != (XmString)NULL)
  745.         _xmstr = XmStringConcat (_xmstr, XmStringSeparatorCreate ());
  746.       /* Used to be XmStringCreate; changed to standard call. */
  747.       _xmstr = XmStringConcat
  748.         (_xmstr, XmStringCreateLtoR (_mstr, XmSTRING_DEFAULT_CHARSET));
  749.     }
  750.  
  751.   fclose (_f);
  752.   return _xmstr;
  753. }
  754.  
  755. /* args do nothing */
  756. XmString XmxMakeXmstrFromString (String mstr)
  757. {
  758.   XmString _xmstr;
  759.  
  760.   _xmstr = XmStringCreateLtoR (mstr, XmSTRING_DEFAULT_CHARSET);
  761.   return _xmstr;
  762. }
  763.  
  764. /* args work */
  765. Widget XmxMakeBboardDialog (Widget parent, String title)
  766. {
  767.   XmxSetArg (XmNdialogTitle,
  768.              XmStringCreateLtoR (title, XmSTRING_DEFAULT_CHARSET));
  769.   XmxSetArg (XmNautoUnmanage, False);
  770.   XmxSetArg (XmNmarginWidth, 0);
  771.   XmxSetArg (XmNmarginHeight, 0);
  772.  
  773.   Xmx_w = XmCreateBulletinBoardDialog (parent, "bbdialog", Xmx_wargs, Xmx_n);
  774.   Xmx_n = 0;
  775.   return Xmx_w;
  776. }
  777.  
  778. /* args work */
  779. Widget XmxMakeFormDialog (Widget parent, String title)
  780. {
  781.   XmxSetArg (XmNdialogTitle,
  782.              XmStringCreateLtoR (title, XmSTRING_DEFAULT_CHARSET));
  783.   XmxSetArg (XmNautoUnmanage, False);
  784.   /* XmxSetArg (XmNdefaultPosition, False); */
  785.  
  786.   Xmx_w = XmCreateFormDialog (parent, "formdialog", Xmx_wargs, Xmx_n);
  787.   Xmx_n = 0;
  788.   return Xmx_w;
  789. }
  790.  
  791. /* args work */
  792. Widget XmxMakeFileSBDialog (Widget parent, String title, String selection_txt,
  793.                             XtCallbackProc cb, int cb_data)
  794. {
  795.   Widget _selection_label;
  796.  
  797.   XmxSetArg (XmNdialogTitle,
  798.              XmStringCreateLtoR (title, XmSTRING_DEFAULT_CHARSET));
  799.   /* Can't set width of box with XmNwidth here... why not? */
  800.  
  801.   /* Create the FileSelectionBox with OK and Cancel buttons. */
  802.   Xmx_w = XmCreateFileSelectionDialog (parent, "fsb", Xmx_wargs, Xmx_n);
  803.   XtUnmanageChild (XmFileSelectionBoxGetChild (Xmx_w, XmDIALOG_HELP_BUTTON));
  804.   XtAddCallback (Xmx_w, XmNokCallback, cb, _XmxMakeClientData (cb_data));
  805.   XtAddCallback (Xmx_w, XmNcancelCallback, _XmxCancelCallback, 0);
  806.  
  807.   /* Set selection label to specified selection_txt. */
  808.   Xmx_n = 0;
  809.   _selection_label = 
  810.     XmFileSelectionBoxGetChild (Xmx_w, XmDIALOG_SELECTION_LABEL);
  811.   XmxSetArg (XmNlabelString, XmStringCreateLtoR (selection_txt,
  812.                                                  XmSTRING_DEFAULT_CHARSET));
  813.   XtSetValues (_selection_label, Xmx_wargs, Xmx_n);
  814.  
  815.   Xmx_n = 0;
  816.   return Xmx_w;
  817. }
  818.  
  819. /* args work */
  820. Widget XmxMakeHelpDialog (Widget parent, XmString xmstr, String title)
  821. {
  822.   XmxSetArg (XmNmessageString, xmstr);
  823.   XmxSetArg (XmNdialogTitle,
  824.              XmStringCreateLtoR (title, XmSTRING_DEFAULT_CHARSET));
  825.  
  826.   Xmx_w = XmCreateMessageDialog (parent, "helpdialog", Xmx_wargs, Xmx_n);
  827.   XtUnmanageChild (XmMessageBoxGetChild (Xmx_w, XmDIALOG_CANCEL_BUTTON));
  828.   XtUnmanageChild (XmMessageBoxGetChild (Xmx_w, XmDIALOG_HELP_BUTTON));
  829.  
  830.   Xmx_n = 0;
  831.   return Xmx_w;
  832. }
  833.  
  834. /* Boy, this is a hack. */
  835. static
  836. XmxCallback(_XmxHelpTextCancelCallback)
  837. {
  838.   /* This is highly dependent on the button being four layers
  839.      below the dialog shell... what a ridiculous hack. */
  840.   XtUnmanageChild (XtParent (XtParent (XtParent (XtParent (w)))));
  841.  
  842.   return;
  843. }
  844.  
  845. /* args work */
  846. Widget XmxMakeHelpTextDialog 
  847.   (Widget parent, String str, String title, Widget *text_w)
  848. {
  849.   Widget _box, _outer_frame, _form;
  850.   Widget _scr_text, _sep, _buttons_form;
  851.  
  852.   /* Create the dialog box. */
  853.   _box = XmxMakeFormDialog (parent, title);
  854.  
  855.   /* Make it 3D. */
  856.   _outer_frame = XmxMakeFrame (_box, XmxShadowOut);
  857.   XmxSetConstraints
  858.     (_outer_frame, XmATTACH_FORM, XmATTACH_FORM, XmATTACH_FORM, XmATTACH_FORM,
  859.      NULL, NULL, NULL, NULL);
  860.  
  861.   /* Put form inside that, then frame for text window. */
  862.   _form = XmxMakeForm (_outer_frame);
  863.  
  864.   /* Make multiline non-editable text window, with scrollbars. */
  865.   XmxSetArg (XmNscrolledWindowMarginWidth, 10);
  866.   XmxSetArg (XmNscrolledWindowMarginHeight, 10);
  867.   XmxSetArg (XmNcursorPositionVisible, False);
  868.   XmxSetArg (XmNeditable, False);
  869.   XmxSetArg (XmNeditMode, XmMULTI_LINE_EDIT);
  870.   XmxSetArg (XmNrows, 20);
  871.   XmxSetArg (XmNcolumns, 60);
  872.   XmxSetArg (XmNwordWrap, True);
  873.   XmxSetArg (XmNscrollHorizontal, False);
  874.   _scr_text = XmxMakeScrolledText (_form);
  875.   XmTextSetString (_scr_text, str);
  876.  
  877.   /* Separate the text window/frame and the OK button. */
  878.   XmxSetArg (XmNtopOffset, 10);
  879.   _sep = XmxMakeHorizontalSeparator (_form);
  880.  
  881.   /* Make an OK button. */
  882.   _buttons_form = XmxMakeFormAndOneButton 
  883.     (_form, _XmxHelpTextCancelCallback, "OK", 0);
  884.  
  885.   /* Constraints for _form. */
  886.   XmxSetConstraints 
  887.     (XtParent (_scr_text), XmATTACH_FORM, XmATTACH_WIDGET, XmATTACH_FORM, 
  888.      XmATTACH_FORM, NULL, _sep, NULL, NULL);
  889.   XmxSetConstraints 
  890.     (_sep, XmATTACH_NONE, XmATTACH_WIDGET, XmATTACH_FORM, XmATTACH_FORM,
  891.      NULL, _buttons_form, NULL, NULL);
  892.   XmxSetConstraints 
  893.     (_buttons_form, XmATTACH_NONE, XmATTACH_FORM, XmATTACH_FORM, XmATTACH_FORM,
  894.      NULL, NULL, NULL, NULL);
  895.  
  896.   /* Return _scr_text in text_w argument. */
  897.   *text_w = _scr_text;
  898.   Xmx_w = _box;
  899.   Xmx_n = 0;
  900.   return Xmx_w;
  901. }
  902.  
  903. /* args work */
  904. void XmxAdjustHelpDialogText (Widget dialog, XmString message,
  905.                               String title)
  906. {
  907.   XmxSetArg (XmNdialogTitle,
  908.              XmStringCreateLtoR (title, XmSTRING_DEFAULT_CHARSET));
  909.   XmxSetArg (XmNmessageString, message);
  910.   XtSetValues (dialog, Xmx_wargs, Xmx_n);
  911.  
  912.   Xmx_n = 0;
  913.   return;
  914. }
  915.  
  916. /* args work */
  917. void XmxAdjustDialogTitle (Widget dialog, String title)
  918. {
  919.   XmxSetArg (XmNdialogTitle, XmStringCreateSimple (title));
  920.   XmxSetValues (dialog);
  921.  
  922.   Xmx_n = 0;
  923.   return;
  924. }
  925.  
  926. /* ------------------------------ SEPARATORS ------------------------------ */
  927.  
  928. /* args work */
  929. Widget XmxMakeHorizontalSeparator (Widget parent)
  930. {
  931.   Xmx_w = XmCreateSeparatorGadget (parent, "separator", Xmx_wargs, Xmx_n);
  932.   XtManageChild (Xmx_w);
  933.  
  934.   Xmx_n = 0;
  935.   return Xmx_w;
  936. }
  937.  
  938. /* args work */
  939. Widget XmxMakeHorizontalSpacer (Widget parent)
  940. {
  941.   XmxSetArg (XmNlabelString,
  942.              XmStringCreateLtoR (" ", XmSTRING_DEFAULT_CHARSET));
  943.   Xmx_w = XtCreateManagedWidget ("label", xmLabelGadgetClass, parent, 
  944.                                  Xmx_wargs, Xmx_n);
  945.   Xmx_n = 0;
  946.   return Xmx_w;
  947. }
  948.  
  949. /* args do nothing */
  950. Widget XmxMakeHorizontalBoundary (Widget parent)
  951. {
  952.   /* To avoid confusion, nullify preloaded resources first. */
  953.   Xmx_n = 0;
  954.   XmxMakeHorizontalSpacer (parent);
  955.   XmxMakeHorizontalSeparator (parent);
  956.   XmxMakeHorizontalSpacer (parent);
  957.  
  958.   Xmx_n = 0;
  959.   return Xmx_w;
  960. }
  961.  
  962. /* ------------------------- TEXT & SCROLLED TEXT ------------------------- */
  963.  
  964. /* args work */
  965. Widget XmxMakeScrolledText (Widget parent)
  966. {
  967.   Xmx_w = XmCreateScrolledText (parent, "scrolledtext",
  968.                 Xmx_wargs, Xmx_n);
  969.   XtManageChild (Xmx_w);
  970.  
  971.   /* Remember this returns the Text Widget, NOT the ScrolledWindow Widget, 
  972.      which is what needs to be tied into a form.  Use XtParent to get the
  973.      actual ScrolledWindow. */
  974.   Xmx_n = 0;
  975.   return Xmx_w;
  976. }
  977.  
  978. /* args work */
  979. Widget XmxMakeText (Widget parent)
  980. {
  981.   Xmx_w = XmCreateText (parent, "text", Xmx_wargs, Xmx_n);
  982.   XtManageChild (Xmx_w);
  983.  
  984.   Xmx_n = 0;
  985.   return Xmx_w;
  986. }
  987.  
  988. /* args do nothing */
  989. void XmxTextSetString (Widget text, String str)
  990. {
  991.   XmTextSetString (text, str);
  992.   return;
  993. }
  994.  
  995. /* args do nothing */
  996. String XmxTextGetString (Widget text)
  997. {
  998.   return XmTextGetString (text);
  999. }
  1000.  
  1001. /* args do nothing */
  1002. void XmxAddCallbackToText (Widget text, XtCallbackProc cb, int cb_data)
  1003. {
  1004.   XtAddCallback (text, XmNactivateCallback, cb, _XmxMakeClientData (cb_data));
  1005.   return;
  1006. }
  1007.  
  1008.  
  1009. /* --------------------------- DRAWING VOLUMES ---------------------------- */
  1010.  
  1011. #ifdef __sgi
  1012. /* args work */
  1013. Widget
  1014. XmxMakeDrawingVolume 
  1015.   (Widget parent, int width, int height,
  1016.    GLXconfig *glxConfig,
  1017.    XtCallbackProc redraw_cb, XtCallbackProc resize_cb,
  1018.    XtCallbackProc ginit_cb)
  1019. {
  1020.   XmxSetArg (XmNwidth, width);
  1021.   XmxSetArg (XmNheight, height);
  1022.   XmxSetArg (GlxNglxConfig, glxConfig);
  1023.  
  1024.   Xmx_w = GlxCreateMDraw (parent, "drawingvolume", Xmx_wargs, Xmx_n);
  1025.   XtManageChild (Xmx_w);
  1026.  
  1027.   XtAddCallback (Xmx_w, GlxNexposeCallback, redraw_cb, _XmxMakeClientData (0));
  1028.   XtAddCallback (Xmx_w, GlxNresizeCallback, resize_cb, _XmxMakeClientData (0));
  1029.   XtAddCallback (Xmx_w, GlxNginitCallback, ginit_cb, _XmxMakeClientData (0));
  1030.  
  1031.   Xmx_n = 0;
  1032.   return Xmx_w;
  1033. }
  1034.  
  1035. void XmxInstallColormaps (Widget toplevel, Widget glw)
  1036. {
  1037.   Window windows[2];
  1038.  
  1039.   windows[0] = XtWindow (glw);
  1040.   windows[1] = XtWindow (toplevel);
  1041.   XSetWMColormapWindows (XtDisplay (toplevel), XtWindow (toplevel),
  1042.              windows, 2);
  1043.   return;
  1044. }
  1045.  
  1046. void XmxInstallColormapsWithOverlay (Widget toplevel, Widget glw)
  1047. {
  1048.   Window windows[5];
  1049.   Window overlay, popup, underlay;
  1050.   Arg args[5];
  1051.   register int i=0;
  1052.   
  1053.   i=0;
  1054.   XtSetArg(args[i], GlxNoverlayWindow, &overlay); i++;
  1055.   XtSetArg(args[i], GlxNpopupWindow, &popup); i++;
  1056.   XtSetArg(args[i], GlxNunderlayWindow, &underlay); i++;
  1057.   XtGetValues(glw, args, i);
  1058.   i = 0;
  1059.   if (overlay)
  1060.     {
  1061.       windows[i] = overlay;
  1062.       i++;
  1063.     }
  1064.   if (popup)
  1065.     {
  1066.       windows[i] = popup;
  1067.       i++;
  1068.     }
  1069.   if (underlay)
  1070.     {
  1071.       windows[i] = underlay;
  1072.       i++;
  1073.     }
  1074.   windows[i] = XtWindow(glw); i++;
  1075.   windows[i] = XtWindow(toplevel); i++;
  1076.   XSetWMColormapWindows(XtDisplay(toplevel), XtWindow(toplevel), windows, i);
  1077.   
  1078.   return;
  1079. }
  1080.  
  1081. void XmxWinset (Widget w)
  1082. {
  1083.   GLXwinset (XtDisplay (w), XtWindow (w));
  1084.   return;
  1085. }
  1086. #endif /* __sgi */
  1087.  
  1088.  
  1089. #ifdef _IBMR2
  1090. /* args work */
  1091. Widget
  1092. XmxMakeDrawingVolume
  1093.   (Widget parent, int width, int height,
  1094.    XtCallbackProc redraw_cb, XtCallbackProc resize_cb,
  1095.    XtCallbackProc ginit_cb)
  1096. {
  1097.   XmxSetArg (XmNwidth, width);
  1098.   XmxSetArg (XmNheight, height);
  1099.  
  1100. #if 0
  1101.   fprintf (stderr, "[Xmx] Going to XtCreateWidget\n");
  1102. #endif
  1103.   Xmx_w = XtCreateWidget
  1104.     ("drawingvolume", glibWidgetClass, parent, Xmx_wargs, Xmx_n);
  1105. #if 0
  1106.   fprintf (stderr, "[Xmx] Done with XtCreateWidget, going to ManageChild\n");
  1107. #endif
  1108.   XtManageChild (Xmx_w);
  1109. #if 0
  1110.   fprintf (stderr, "[Xmx] Done with ManageChild\n");
  1111. #endif
  1112.  
  1113.   XtAddCallback (Xmx_w, XglNexposeCallback, redraw_cb, _XmxMakeClientData (0));
  1114.   XtAddCallback (Xmx_w, XglNresizeCallback, resize_cb, _XmxMakeClientData (0));
  1115.   XtAddCallback (Xmx_w, XglNgconfigCallback, ginit_cb, _XmxMakeClientData (0));
  1116.  
  1117. #if 0
  1118.   fprintf (stderr, "[Xmx] Leaving MakeDrawingVolume\n");
  1119. #endif
  1120.   Xmx_n = 0;
  1121.   return Xmx_w;
  1122. }
  1123.  
  1124. void XmxInstallColormaps (Widget toplevel, Widget glw)
  1125. {
  1126.   return;
  1127. }
  1128.  
  1129. void XmxWinset (Widget w)
  1130. {
  1131.   GlWinsetWidget (w);
  1132.   return;
  1133. }
  1134. #endif /* _IBMR2 */
  1135.  
  1136. /* ----------------------------- BITMAP UTILS ----------------------------- */
  1137.  
  1138. /* args ignored and reset */
  1139. void XmxApplyBitmapToLabelWidget
  1140.   (Widget label, String data, unsigned int width, unsigned int height)
  1141. {
  1142.   Display *_disp;
  1143.   Pixel _fg, _bg;
  1144.   Pixmap _pix;
  1145.  
  1146.   _disp = XtDisplay (label);
  1147.  
  1148.   Xmx_n = 0;
  1149.   XmxSetArg (XmNforeground, &_fg);
  1150.   XmxSetArg (XmNbackground, &_bg);
  1151.   XtGetValues (label, Xmx_wargs, Xmx_n);
  1152.   Xmx_n = 0;
  1153.  
  1154.   _pix = XCreatePixmapFromBitmapData
  1155.     (_disp, DefaultRootWindow (_disp), data, width, height, _fg, _bg,
  1156.      DefaultDepthOfScreen (DefaultScreenOfDisplay (_disp)));
  1157.   XmxSetArg (XmNlabelPixmap, _pix);
  1158.   XmxSetArg (XmNlabelType, XmPIXMAP);
  1159.   XmxSetValues (label);
  1160.  
  1161.   Xmx_n = 0;
  1162.   return;
  1163. }
  1164.  
  1165. /* ------------------------ DIALOG CONTROL BUTTONS ------------------------ */
  1166.  
  1167. /* args apply to form */
  1168. Widget XmxMakeFormAndOneButton (Widget parent, XtCallbackProc cb, 
  1169.                                 String name1, int cb_data1)
  1170. {
  1171.   Widget _form, _button1;
  1172.  
  1173.   XmxSetArg (XmNverticalSpacing, 8);
  1174.   XmxSetArg (XmNfractionBase, 3);
  1175.   _form = XmxMakeForm (parent);
  1176.  
  1177.   _button1 = XmxMakePushButton (_form, name1, cb, cb_data1);
  1178.  
  1179.   XmxSetConstraints 
  1180.     (_button1, XmATTACH_FORM, XmATTACH_FORM, XmATTACH_NONE, XmATTACH_NONE,
  1181.      NULL, NULL, NULL, NULL);
  1182.   XmxSetPositions (_button1, XmxNoPosition, XmxNoPosition, 1, 2);
  1183.   XmxSetOffsets (_button1, XmxNoOffset, XmxNoOffset, 8, 8);
  1184.   
  1185.   Xmx_n = 0;
  1186.   Xmx_w = _form;
  1187.   return Xmx_w;
  1188. }
  1189.  
  1190. /* args apply to form */
  1191. Widget XmxMakeFormAndTwoButtons 
  1192.   (Widget parent, XtCallbackProc cb,
  1193.    String name1, String name2,
  1194.    int cb_data1, int cb_data2)
  1195. {
  1196.   Widget _form, _button1, _button2;
  1197.  
  1198.   XmxSetArg (XmNverticalSpacing, 8);
  1199.   XmxSetArg (XmNfractionBase, 2);
  1200.   _form = XmxMakeForm (parent);
  1201.  
  1202.   _button1 = XmxMakePushButton (_form, name1, cb, cb_data1);
  1203.   _button2 = XmxMakePushButton (_form, name2, cb, cb_data2);
  1204.  
  1205.   XmxSetConstraints 
  1206.     (_button1, XmATTACH_FORM, XmATTACH_FORM, XmATTACH_NONE, XmATTACH_NONE,
  1207.      NULL, NULL, NULL, NULL);
  1208.   XmxSetConstraints 
  1209.     (_button2, XmATTACH_FORM, XmATTACH_FORM, XmATTACH_NONE, XmATTACH_NONE,
  1210.      NULL, NULL, NULL, NULL);
  1211.   XmxSetPositions (_button1, XmxNoPosition, XmxNoPosition, 0, 1);
  1212.   XmxSetPositions (_button2, XmxNoPosition, XmxNoPosition, 1, 2);
  1213.   XmxSetOffsets (_button1, XmxNoOffset, XmxNoOffset, 8, 4);
  1214.   XmxSetOffsets (_button2, XmxNoOffset, XmxNoOffset, 4, 8);
  1215.   
  1216.   Xmx_n = 0;
  1217.   Xmx_w = _form;
  1218.   return Xmx_w;
  1219. }
  1220.  
  1221. /* args apply to form */
  1222. Widget XmxMakeFormAndTwoButtonsSqueezed
  1223.   (Widget parent, XtCallbackProc cb,
  1224.    String name1, String name2,
  1225.    int cb_data1, int cb_data2)
  1226. {
  1227.   Widget _form, _button1, _button2;
  1228.  
  1229.   XmxSetArg (XmNverticalSpacing, 8);
  1230.   XmxSetArg (XmNfractionBase, 5);
  1231.   _form = XmxMakeForm (parent);
  1232.  
  1233.   _button1 = XmxMakePushButton (_form, name1, cb, cb_data1);
  1234.   _button2 = XmxMakePushButton (_form, name2, cb, cb_data2);
  1235.  
  1236.   XmxSetConstraints 
  1237.     (_button1, XmATTACH_FORM, XmATTACH_FORM, XmATTACH_NONE, XmATTACH_NONE,
  1238.      NULL, NULL, NULL, NULL);
  1239.   XmxSetConstraints 
  1240.     (_button2, XmATTACH_FORM, XmATTACH_FORM, XmATTACH_NONE, XmATTACH_NONE,
  1241.      NULL, NULL, NULL, NULL);
  1242.   XmxSetPositions (_button1, XmxNoPosition, XmxNoPosition, 1, 2);
  1243.   XmxSetPositions (_button2, XmxNoPosition, XmxNoPosition, 3, 4);
  1244.   XmxSetOffsets (_button1, XmxNoOffset, XmxNoOffset, 8, 4);
  1245.   XmxSetOffsets (_button2, XmxNoOffset, XmxNoOffset, 4, 8);
  1246.   
  1247.   Xmx_n = 0;
  1248.   Xmx_w = _form;
  1249.   return Xmx_w;
  1250. }
  1251.  
  1252. /* args apply to form */
  1253. Widget XmxMakeFormAndThreeButtons 
  1254.   (Widget parent, XtCallbackProc cb,
  1255.    String name1, String name2, String name3,
  1256.    int cb_data1, int cb_data2, int cb_data3)
  1257. {
  1258.   Widget _form, _button1, _button2, _button3;
  1259.  
  1260.   XmxSetArg (XmNverticalSpacing, 8);
  1261.   XmxSetArg (XmNfractionBase, 3);
  1262.   _form = XmxMakeForm (parent);
  1263.  
  1264.   _button1 = XmxMakePushButton (_form, name1, cb, cb_data1);
  1265.   _button2 = XmxMakePushButton (_form, name2, cb, cb_data2);
  1266.   _button3 = XmxMakePushButton (_form, name3, cb, cb_data3);
  1267.  
  1268.   XmxSetConstraints 
  1269.     (_button1, XmATTACH_FORM, XmATTACH_FORM, XmATTACH_NONE, XmATTACH_NONE,
  1270.      NULL, NULL, NULL, NULL);
  1271.   XmxSetConstraints 
  1272.     (_button2, XmATTACH_FORM, XmATTACH_FORM, XmATTACH_NONE, XmATTACH_NONE,
  1273.      NULL, NULL, NULL, NULL);
  1274.   XmxSetConstraints 
  1275.     (_button3, XmATTACH_FORM, XmATTACH_FORM, XmATTACH_NONE, XmATTACH_NONE,
  1276.      NULL, NULL, NULL, NULL);
  1277.   XmxSetPositions (_button1, XmxNoPosition, XmxNoPosition, 0, 1);
  1278.   XmxSetPositions (_button2, XmxNoPosition, XmxNoPosition, 1, 2);
  1279.   XmxSetPositions (_button3, XmxNoPosition, XmxNoPosition, 2, 3);
  1280.   XmxSetOffsets (_button1, XmxNoOffset, XmxNoOffset, 8, 4);
  1281.   XmxSetOffsets (_button2, XmxNoOffset, XmxNoOffset, 4, 4);
  1282.   XmxSetOffsets (_button3, XmxNoOffset, XmxNoOffset, 4, 8);
  1283.   
  1284.   Xmx_n = 0;
  1285.   Xmx_w = _form;
  1286.   return Xmx_w;
  1287. }
  1288.